package equifax.wscollectormate.bussines;

import equifax.wscollectormate.bean.Mensaje;

import java.io.File;
import java.rmi.RemoteException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import javax.swing.JOptionPane;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import equifax.wscollectormate.bean.Usuario;
import equifax.wscollectormate.bean.VariableReporte;
import equifax.wscollectormate.run.xmlString;
import equifax.wscollectormate.soa.BureauServiceException;
import equifax.wscollectormate.util.CsvFromXml;
import equifax.wscollectormate.util.FileManager;
import equifax.wscollectormate.util.JavaUtils;
import equifax.wscollectormate.util.LeerArchivoCsv;
import equifax.wscollectormate.util.LeerXml;

  public class ClienteControlador 
  {
  
	  private static final Logger log = Logger.getLogger("equifax.wscollectormate.bussines"); 
	  public FileManager archivoCsv = null;
	  public boolean suspenderEjecucion = false;
	  
	  public int contadorProblemasConeccion = 0;
	  public int numCatalogoErroresConnecion = 0;
      public int contClientesTransaccionExitosaInfDisponible = 0;
      public int contClientesTransaccionExitosaInfNoEncontrada = 0;
      public int contClientesSinInformacion = 0;
      public int contClientesOtrosCodigoTransaccion = 0;
      public int contClientesExcepcion = 0;
      
      public int contClientes = 0;
      public int contadorConsultasNIT = 0;
      public int contadorConsultasDUI = 0; 
	  //Existen 3 categorias de respuesta
	  //1) EXITO
	  //2) FALLIDA
	  //3) CONNECCION	  
	  public String categoriaRespuesta; 
	  public int contadorConsultasResExito = 0;
	  public int contadorConsultasResFallo = 0;
	  public int contadorConsultasResConeccion = 0; 
	  public int contadorConsultaProblemasConeccionRed = 0;
	  public int cantidadConsultasRealizadas = 0;
	  //cantidad de segundos a dormir la aplicacion en caso de problemas de conecccion
	  public int cantidadSegundosInactividad = 0;
	  
	  String cantidadDigitosDui;
	  String cantidadDigitosNit;
	  String formatoReporte = "";
	  //Excepciones
	  String excConnectionRed;
	  String excSinMensaje;
	  String excSinVariablesRetorno;
	  
	  HashMap<String, Mensaje>  hashRespuesta = new HashMap<String , Mensaje>();
	  
	  
	  
	  public void procesarCliente(String nombreDocumento, String numeroDocumento)
	  {
		    FileManager archivo = null;
	    	FileManager archivoLog = null;
	    	String directorioEjecucionEquifax = JavaUtils.getPropiedad("directorio.ejecucion.equifax");
	    	crearDirectorioEquifax(directorioEjecucionEquifax);
	    	try
	    	{
		    	String respuesta = consultarEquifaxCliente(nombreDocumento, numeroDocumento);
		    	VariableReporte var = consultarVariable(respuesta);
		    	String codigoRetornoExito   = JavaUtils.getPropiedad("codigo.retorno[exito]");
		    	
		    	archivo = new FileManager();
				String rutaAbsoluta = directorioEjecucionEquifax.concat(JavaUtils.getPropiedad("archivo.clientes.equifax"));
				archivo.crearArchivo(rutaAbsoluta);
				
				archivoLog = new FileManager();
				archivoLog.crearArchivo(directorioEjecucionEquifax.concat(JavaUtils.getPropiedad("archivo.log.equifax")));
				
			     /* *** ENCABEZADO DEL ARCHIVO A PROCESAR **** */  
				Calendar cal = Calendar.getInstance();
				archivoLog.escribirTextoSL("--------------------------------------------------------");
				archivoLog.escribirTextoSL("|         INICIA PROCESAMIENTO DE CLIENTE               |\n");            
				archivoLog.escribirTextoSL("--------------------------------------------------------\n");
				archivoLog.escribirTextoSL("================== Inicio de proceso CollectorMate: "+(new SimpleDateFormat("ddMMM hh:mm")).format(cal.getTime()) + " ==================\n\n");
		      
				//Escribimos el encabezado en el archivo de procesamiento de equifax que contendra los clientes	
			    archivo.escribirTextoSL(JavaUtils.getPropiedad("csv[column.names]").replace("-", ","));
		    	
		    	if(StringUtils.containsOnly(var.getCodigoRetorno(), codigoRetornoExito))
				{	
					String csvFroXml = CsvFromXml.csvFromXml(respuesta); 
					archivo.escribirTexto(csvFroXml);	
					JOptionPane.showMessageDialog(null, "Cliente procesado exitosamente ");	
				}
		    	else
		    	{
		    		JOptionPane.showMessageDialog(null, var.getCodigoRetorno()+" - "+var.getMensaje());	
		    	}	
		    	log.info("Procesando "+nombreDocumento+" con numero: "+numeroDocumento);	
		    	log.info("RESULTADO > codigo: "+var.getCodigoRetorno()+" mensaje: "+var.getMensaje());
				archivoLog.escribirTextoSL("Procesando "+nombreDocumento+" con numero: "+numeroDocumento);	
				archivoLog.escribirTextoSL("RESULTADO > codigo: "+var.getCodigoRetorno()+" mensaje: "+var.getMensaje());
	        }
			catch(Exception e)
	        {
	        	e.printStackTrace();
	        }
			
			finally
			{
				Calendar cal = Calendar.getInstance();
			    archivoLog.escribirTextoSL("--------------------------------------------------------");
			    archivoLog.escribirTextoSL("|           FIN PROCESAMIENTO DE CLIENTE                |\n");            
			    archivoLog.escribirTextoSL("--------------------------------------------------------\n");
			    archivoLog.escribirTextoSL("================== Fin de proceso CollectorMate: "+(new SimpleDateFormat("ddMMM hh:mm")).format(cal.getTime()) + " ==================\n\n");
	 	   	
	 	        archivo.cerrarArchivo();
	 	        archivoLog.cerrarArchivo();
	 	        JavaUtils.abrirArchivoConSO(directorioEjecucionEquifax);
			}  
	  }
	  
	  public void cargarExcepciones()
	  {
			excConnectionRed       = JavaUtils.getPropiedad("EX1");
			excSinMensaje          = JavaUtils.getPropiedad("EX2");
			excSinVariablesRetorno = JavaUtils.getPropiedad("EX3"); 
	  }
	  

	  public void procesarClientes(File archivoClientes)
	  {
		System.out.println(" * INICIALIZANDO EJECUCION APLICATIVO * ");
		FileManager archivoLog = null;
		boolean consultarConOtroDocumento = false;
		
		//Obtenemos Informaciones para generar el archivo de log
		String InformacionClienteProcesado = JavaUtils.getPropiedad("ARCHIVO_LOG[REGISTRO_EN_PROCESO]");
	    String InformacionResultadoProceso = JavaUtils.getPropiedad("ARCHIVO_LOG[RESULTADO_PROCESO_REG]");
        String DescripcionResultadoProceso = JavaUtils.getPropiedad("ARCHIVO_LOG[DESCRIPCION_RESULTADO]");
        numCatalogoErroresConnecion = Integer.parseInt(JavaUtils.getPropiedad("codigos.retorno.error.cantidad").trim());        
		int maxConnectionValid = Integer.parseInt(JavaUtils.getPropiedad("max.connection.valid.failed").trim());
		cantidadSegundosInactividad = Integer.parseInt(JavaUtils.getPropiedad("time.sleep.execution").trim());
		formatoReporte = JavaUtils.getPropiedad("format.reporte.ejecucion");
		cargarExcepciones();
		

        
        //Informacion del Cliente
		String nombreCliente = "";
		String tipoDocumento = "";
		String numeroDocumento = "";
		

		String directorioEjecucionEquifax = JavaUtils.getPropiedad("directorio.ejecucion.equifax");
		crearDirectorioEquifax(directorioEjecucionEquifax);
		
		archivoLog = new FileManager();
		archivoLog.crearArchivo(directorioEjecucionEquifax.concat(JavaUtils.getPropiedad("archivo.log.equifax")));
		archivoLog.escribirTexto(JavaUtils.getPropiedad("ARCHIVO_LOG[ENCABEZADO]").replace("[TIEMPO_EJECUCION]", (new SimpleDateFormat("ddMMM hh:mm")).format(Calendar.getInstance().getTime())));

		archivoCsv = new FileManager();
		archivoCsv.crearArchivo(directorioEjecucionEquifax.concat(JavaUtils.getPropiedad("archivo.clientes.equifax")));

        LeerArchivoCsv csv = new LeerArchivoCsv();
	    List<String[]> listaInformacionClientes  = csv.obtenerTodosLosRegistros(archivoClientes.getAbsolutePath());   
	    
		archivoLog.escribirTextoSL("CANTIDAD DE REGISTROS EN EL ARCHIVO CARGADO: "+listaInformacionClientes.size()+"\n");
		
	    for(String[] cliente :listaInformacionClientes)
		{
	      if(contadorProblemasConeccion == 3)
	      {
           	 break;  
	       }
		      try
		       {
			    	nombreCliente = getNombreCompleto(cliente[0], cliente[1]);
			    	log.info("PROCESANDO AL CLIENTE "+(++contClientes));
			    	
			    	/***************************************************************************************/
			    	/*     REALIZAMOS LA CONSULTA CON EL DOCUMENTO UNICO DE IDENTIDAD
			    	/***************************************************************************************/

					if(cliente[2].isEmpty() == false)
					{	
						if(contadorProblemasConeccion == 3)
					     {
				           	 break;  
					     }
				        //incrementamos el contador de consultas con DUI antes de realizarla
					    ++contadorConsultasDUI;
						   
					    //Obtenemos los dos parametros necesarios para realizar la consulta al webservice
					    tipoDocumento = "DUI";
					    numeroDocumento = cliente[2];
					   
					    //Escribimos en el log el cliente que se procesara
					    String registro = InformacionClienteProcesado.replace("[NUM_RECORD]", String.valueOf(contClientes)).replace("[NOMBRE_CLIENTE]", nombreCliente).replace("[TIPO_DOCUMENTO]", tipoDocumento).replace("[NUM_DOCUMENTO]", numeroDocumento);
					    archivoLog.escribirTextoSL(registro);
					    log.info(registro);
					   		  
					    //hacemos la consulta con el dui
					     String respuesta = "";
					     respuesta = consultarEquifaxCliente(JavaUtils.getPropiedad("cliente[2]"), cliente[2]);
					     
					   
					         //verificamos que la respuesta no este vacia de caso contrario notificar que la respuesta no contenia ningun valor 
						     if(existeRespuestaEquifax(respuesta, archivoLog, InformacionResultadoProceso))
						     {					    	 							 
								    if(categoriaRespuesta.equals("EXITO"))
								    {
								    	escribirContenidoEnCsv(respuesta, DescripcionResultadoProceso, archivoLog);	
									}
									if(categoriaRespuesta.equals("FALLIDA"))
									{
										consultarConOtroDocumento = (!cliente[3].isEmpty()); 
										archivoLog.escribirTextoSL(DescripcionResultadoProceso.replace("[DESCRIPCION]", "[NO_EXITOSO] LA TRANSACCION CON EQUIFAX DEVOLVIO UN RESULTADO NO EXITOSO"));
									} 
									if(categoriaRespuesta.equals("CONECCION"))
									{
										consultarConOtroDocumento = (!cliente[3].isEmpty()); 
										sleepExecution();
										archivoLog.escribirTextoSL(DescripcionResultadoProceso.replace("[DESCRIPCION]", "[PROBLEMA_CONECCION] LA TRANSACCION CON EQUIFAX DEVOLVIO PROBLEMAS DE CONECCION"));
									}
						     }
						     //si codigo ni mensaje no existe la cadena de Xml viene vacia
						     else
						     {
						    	 consultarConOtroDocumento = (!cliente[3].isEmpty()); 
						     }
					   }
					     
					     /***************************************************************************************/
					     /*     REALIZAMOS LA CONSULTA CON EL NUMERO DE IDENTIFICACION TRIBUTARIA
					     /***************************************************************************************/					     
					     if(consultarConOtroDocumento)
					     {
					    	 if(contadorProblemasConeccion == 3)
						     {
					           	 break;  
						     }
					    	//incremetamos el contador de intentos de consulta de NIT antes de la consulta
			   				 ++contadorConsultasNIT;
			   				 
			   			    //Obtenemos los dos parametros necesarios para realizar la consulta al webservice
							 tipoDocumento = "NIT";
							 numeroDocumento = cliente[3];
							   
							 //Escribimos en el log el cliente que se procesara
							 archivoLog.escribirTextoSL(InformacionClienteProcesado.replace("[NUM_RECORD]", String.valueOf(contClientes)).replace("[NOMBRE_CLIENTE]", nombreCliente).replace("[TIPO_DOCUMENTO]", tipoDocumento).replace("[NUM_DOCUMENTO]", numeroDocumento));
					    	 
							//hacemos la consulta con el dui
						     String respuesta = "";
						     respuesta = consultarEquifaxCliente(JavaUtils.getPropiedad("cliente[3]"), cliente[3]);
						     
						   //verificamos que la respuesta no este vacia de caso contrario notificar que la respuesta no contenia ningun valor 
						     if(existeRespuestaEquifax(respuesta, archivoLog, InformacionResultadoProceso))
						     {					    	 							 
								    if(categoriaRespuesta.equals("EXITO"))
								    {
								    	escribirContenidoEnCsv(respuesta, DescripcionResultadoProceso, archivoLog);	
									}
									if(categoriaRespuesta.equals("FALLIDA"))
									{
										consultarConOtroDocumento = (!cliente[3].isEmpty()); 
										++contClientesOtrosCodigoTransaccion;
										archivoLog.escribirTextoSL(DescripcionResultadoProceso.replace("[DESCRIPCION]", "[NO_EXITOSO] LA TRANSACCION CON EQUIFAX DEVOLVIO UN RESULTADO NO EXITOSO"));
									} 
									if(categoriaRespuesta.equals("CONECCION"))
									{
										 ++contadorProblemasConeccion;
										 sleepExecution();
										 archivoLog.escribirTextoSL(DescripcionResultadoProceso.replace("[DESCRIPCION]", "[PROBLEMA_CONECCION] LA TRANSACCION CON EQUIFAX DEVOLVIO PROBLEMAS DE CONECCION"));
									}
						     }
						     else
						     {
						    	 ++contClientesExcepcion;
						     } 
						  
					    	 
					     }

		       }
		       catch(Exception e)
		       {
		    	  log.error("Excepcion: "+e.getMessage()+" ");   
		    	  VariableReporte var = new VariableReporte("EX1", excConnectionRed+" "+e.getMessage());
		    	  evaluarCodigoRespuesta(var.getCodigoRetorno());
		    	  clasificarResultadoEquifax(var);
				  archivoLog.escribirTextoSL(var.getCodigoRetorno()+" "+var.getMensaje());
				  sleepExecution();
				  ++contadorConsultaProblemasConeccionRed;
				  ++contadorProblemasConeccion;

				  if(contadorProblemasConeccion == 3)
		    	  {
	            	 break;  
		    	  }
		    	  e.printStackTrace();
		    	 
		       }

		      finally
		      {
		    	//inicializamos las variables nombre, tipo Documento, y numero de Documento
		    	  nombreCliente = "";
		    	  tipoDocumento = "";
		    	  numeroDocumento = "";
		    	  categoriaRespuesta = "";
		    	  consultarConOtroDocumento = false;
		    	  archivoLog.escribirTexto("\n");
		      }
	
			}
		    
		    if(contadorProblemasConeccion == 3)
		    {
			    log.info("El Webservice de equifax a excedido al numero maximo de conneciones fallidas permitidas ("+maxConnectionValid+") por favor consulte con el proveedor equifax");
				archivoLog.escribirTextoSL("[ERROR_CONECCION]: El Webservice de equifax a excedido al numero maximo de conneciones fallidas permitidas ("+maxConnectionValid+") \n por favor consulte con el proveedor equifax");
                System.out.println("El Webservice de equifax a excedido al numero maximo de conneciones fallidas permitidas ("+maxConnectionValid+")\n por favor consulte con el proveedor equifax");
		    }
		    
		    log.info("   TOTAL DE CLIENTES QUE SE PROCESARON : "+contClientes+" CLIENTES ");	
			archivoLog.escribirTexto(JavaUtils.getPropiedad("ARCHIVO_LOG[PIE]").replace("[TIEMPO_EJECUCION]", (new SimpleDateFormat("ddMMM hh:mm")).format(Calendar.getInstance().getTime())));
		    archivoLog.cerrarArchivo();
		    JavaUtils.abrirArchivoConSO(directorioEjecucionEquifax);
		    imprimirReporte(directorioEjecucionEquifax, getResumen());


	 }
	    
	  public void clasificarResultadoEquifax(VariableReporte var)
	  {  
		 if(hashRespuesta.isEmpty())
		 {
			hashRespuesta.put(var.getCodigoRetorno(), new Mensaje(var.getMensaje()));
		 }
		 else
		 {
		    buscarCodigoRespuesta(var);
		 }
	  }
	  
	  public void buscarCodigoRespuesta(VariableReporte var)
	  {
		  if(hashRespuesta.containsKey(var.getCodigoRetorno()))
		  {
				Mensaje m = (Mensaje)hashRespuesta.get(var.getCodigoRetorno());
				m.incrementar();
				hashRespuesta.put(var.getCodigoRetorno(), m );
		  } 
		  else{
		  	    hashRespuesta.put(var.getCodigoRetorno(), new Mensaje(var.getMensaje()));
			}  
	  }
	  
	  public void sleepExecution()
	  {		  
		  try {
			  String s = "Total de segundos en espera antes de una nueva consulta por problemas de coneccion "+this.cantidadSegundosInactividad+"\n";					  
			  System.out.println(s);
			  for(int i=1; i < this.cantidadSegundosInactividad; i++){
				  System.out.print(i+" ");
				  Thread.sleep(1000);
			  } 
			  System.out.println("\n");
			} catch (InterruptedException ie) 
			{
			   ie.printStackTrace();
			}   
	  }
	  
	  public String getResumen ()
	  {
		  String resumenCliente = "\n*\t RESUMEN CLIENTES\t* \n" +
 		         "---------------------------------------------------------------------------------------------------------\n" +
 		         "       TOTAL DE CLIENTES QUE SE PROCESARON : "+contClientes+" CLIENTES \n" +
 		         "---------------------------------------------------------------------------------------------------------\n" +
 		         "            CLIENTES CODIGO '00' TRANSACCION EXITOSA INF DISPONIBLE         : "+contClientesTransaccionExitosaInfDisponible+" CLIENTES \n" +
 		         "            CLIENTES CODIGO '00' TRANSACCION EXITOSA INF NO DISPONIBLE      : "+contClientesTransaccionExitosaInfNoEncontrada+" CLIENTES \n" +
 		         "            CLIENTES CODIGO 'XX' OTRO TIPO DE RESPUESTA POR EL WEBSERVICE   : "+contClientesOtrosCodigoTransaccion+" CLIENTES \n"+
 		         "            CLIENTES CON EXCEPCION EN LA CONSULTA REALIZADA                 : "+contClientesExcepcion+" CLIENTES \n"+
 		         "            CLIENTES CON PROBLEMA DE CONECCION EQUIFAX                      : "+contadorProblemasConeccion+" CLIENTES \n"+
 		         "---------------------------------------------------------------------------------------------------------\n";

		  String resumenConsultas = "\n*\t RESUMEN CONSULTAS\t* \n\n" +
 		                 "---------------------------------------------------------------------------------------------------------\n" +
 		                 "       TOTAL INTENTOS DE CONSULTAS : "+(cantidadConsultasRealizadas)+" CONSULTAS \n" +
 		                 "---------------------------------------------------------------------------------------------------------" ;
 		                /* "            CONSULTAS CON RESULTADO TRANSACCION EXITOSA (DEVUELTO POR EQUIFAX)              : "+contadorConsultasResExito+" CONSULTAS  \n" +
 		                 "            CONSULTAS CON OTRO TIPO DE RESULTADO (DEVUELTO POR EQUIFAX)                     : "+contadorConsultasResFallo+" CONSULTAS  \n" +
 		                 "            CONSULTAS CON RESULTADO PROBLEMAS DE CONECCION (DEVUELTO POR EQUIFAX)           : "+contadorConsultasResConeccion+" CONSULTAS  \n" +
 		                 "            CONSULTAS CON RESULTADO PROBLEMAS DE CONECCION EN LA RED                        : "+contadorConsultaProblemasConeccionRed+" CONSULTAS  \n" +
 		                 "---------------------------------------------------------------------------------------------------------\n\n" +
 		                 "\t*\t Resumen consultas por tipo de documento consultado\t* \n\n" +
 		                 "---------------------------------------------------------------------------------------------------------\n" +
 		                 "       TOTAL INTENTOS DE CONSULTAS POR TIPO DE RESULTADO: "+(contadorConsultasDUI+contadorConsultasNIT)+" CONSULTAS \n" +
 		                 "          DETALLE POR TIPO DE DOCUMENTO : \n" +
 		                 "---------------------------------------------------------------------------------------------------------\n" +
 		                 "            CONSULTAS CON DUI               : "+contadorConsultasDUI+" CONSULTAS  \n" +
 		                 "            CONSULTAS CON NIT               : "+contadorConsultasNIT+" CONSULTAS  \n" +
 		                 "---------------------------------------------------------------------------------------------------------\n" ;*/

            return resumenCliente.concat(resumenConsultas);
		 } 
	  
	 public void imprimirReporte(String directorioEjecucionEquifax, String resumen)
	 {
		 FileManager archivoResumen = new FileManager();
	     archivoResumen.crearArchivo(directorioEjecucionEquifax.concat(JavaUtils.getPropiedad("archivo.resumen.equifax")));      	 
	     
	     archivoResumen.escribirTextoSL(resumen);	
	     log.info(resumen);
	     log.info("\n");
	     
	     String formatStr = "%-15s %-80s %-18s";
	     
	        String key;
		   Mensaje value;
		   Iterator iterator = hashRespuesta.keySet().iterator();
		   
		   archivoResumen.escribirTextoSL(String.format(formatStr, "CODIGO","MENSAJE","CANTIDAD"));
		   archivoResumen.escribirTextoSL("---------------------------------------------------------------------------------------------------------\n");
		   while (iterator.hasNext()) {
		       key = (String) iterator.next();
		       value =  hashRespuesta.get(key);
		       archivoResumen.escribirTextoSL(String.format(formatStr, key, value.getMensaje(), value.getContador()));
		   }
	     
	 } 
	  
	  
	
	  
     public void escribirContenidoEnCsv(String respuesta, String DescripcionResultadoProceso, FileManager archivoLog)
     {
    	 //Intentamos obtener la informacion de la direccion o telefono	 
    	 String csvFromXml = "";
		 csvFromXml = CsvFromXml.csvFromXml(respuesta);
	     //evaluamos que dicha informacion exista
			 if(csvFromXml.trim().isEmpty() == false)
			 {
	    	   //si existe comentar que dicha informacion existe en el log y escribir el contenido en el csv
				 ++contClientesTransaccionExitosaInfDisponible;
				 archivoCsv.escribirTextoSL(csvFromXml);	
				 String descripcion = DescripcionResultadoProceso.replace("[DESCRIPCION]", "[DISPONIBLE] INFORMACION DISPONIBLE EN CSV");
				 archivoLog.escribirTextoSL(descripcion);
				 log.info(descripcion);
				 
			 }
			 else
			 {
		       //si no comentar que dicha informacion no existe
				 ++contClientesTransaccionExitosaInfNoEncontrada;
				 String descripcion = DescripcionResultadoProceso.replace("[DESCRIPCION]", "[NO_ENCONTRADA] INFORMACION DIRECCION/TELEFONO NO ENCONTRADA EN EL XML DEVUELTO");
				 archivoLog.escribirTextoSL(descripcion);
				 log.info(descripcion);
			 } 
     }
	  
	 public boolean existeRespuestaEquifax(String respuesta, FileManager archivoLog, String InformacionResultadoProceso)
	 {
		 if(respuesta.isEmpty() == false)
	     {
	    	 return existeVariableReporte(respuesta, archivoLog, InformacionResultadoProceso );	 
	     }
	     else
	     {
	       VariableReporte var = new VariableReporte("EX2", excSinMensaje);
	       categoriaRespuesta = "EXCEPCION";
	       clasificarResultadoEquifax(var);
	       escribirRespuestaEnLog(var, archivoLog, InformacionResultadoProceso);
		   return false;
	     } 
	 } 
	 
	 public boolean existeVariableReporte(String respuesta, FileManager archivoLog, String InformacionResultadoProceso)
	 {
		 VariableReporte var = consultarVariable(respuesta);
    	 if(var.getCodigoRetorno().isEmpty() == false && var.getMensaje().isEmpty() == false)
    	 {
    		clasificarResultadoEquifax(var);
    		escribirRespuestaEnLog(var, archivoLog, InformacionResultadoProceso);
  	        evaluarCodigoRespuesta(var.getCodigoRetorno());
    	    return true;
    	 }
    	 else
    	 {
    		var.setCodigoRetorno("EX3"); var.setMensaje(excSinVariablesRetorno);
    		categoriaRespuesta = "EXCEPCION";
    		clasificarResultadoEquifax(var);
 	        escribirRespuestaEnLog(var, archivoLog, InformacionResultadoProceso);
    	    return false;
    	 } 
	 }
	 
	 public void escribirRespuestaEnLog(VariableReporte var, FileManager archivoLog, String InformacionResultadoProceso)
	 {
 	    archivoLog.escribirTextoSL(InformacionResultadoProceso.replace("[CODIGO]", var.getCodigoRetorno()).replace("[MENSAJE]", var.getMensaje())); 
	 }
	 
	 
	 public boolean evaluarCodigoRespuesta(String codigo)
	 {	 
		if(codigo.equals(JavaUtils.getPropiedad("codigo.retorno[exito]")))
		{
			++contadorConsultasResExito;
			categoriaRespuesta = "EXITO";
			return true;
		} 
		for(int i=0; i < numCatalogoErroresConnecion; i++)
		{
		   String codError = JavaUtils.getPropiedad("codigo.retorno.error.coneccion["+i+"]");
		   if(codigo.equals(codError))
		   {
			   ++contadorConsultasResConeccion;
			   categoriaRespuesta = "CONECCION";
			   return false;
		   }	
		 }
		 //incrementamos la variable contador dado que el codigo de transaccion devuelto es diferente a exitoso
		++contadorConsultasResFallo;
		 categoriaRespuesta = "FALLIDA";	
		 return false;
		
	 }
	  
	  
	

	  
	 public String getNombreCompleto(String cadena1, String cadena2){
		 return cadena1.concat(" ").concat(cadena2);
	 } 
	  
	 @SuppressWarnings("finally")
	 public int validarClientes(File archivoClientes)
	 {
 	    int cantidadValidaCampos = Integer.parseInt(JavaUtils.getPropiedad("csv[row.length]"));
 	    this.cantidadDigitosDui = JavaUtils.getPropiedad("cliente.dui[digitos]");
 	    this.cantidadDigitosNit = JavaUtils.getPropiedad("cliente.nit[digitos]");
		int contadorRegistrosErroneos = 0;
		FileManager archivo =  null;
	  try
		{
		    LeerArchivoCsv csv = new LeerArchivoCsv();
		    List<String[]> listaInformacionClientes  = csv.obtenerTodosLosRegistros(archivoClientes.getAbsolutePath());	 	    
			int registroLeido = 1;
		    for(String[] cliente :listaInformacionClientes)
			{
		      String registro = obtenerRegistro(cliente);
		      boolean resultadoCantidadValidaColumnas = cliente.length == cantidadValidaCampos?true:false;
		     
		      if(resultadoCantidadValidaColumnas)
              {
	            	log.info("validarDatos cliente: "+validarDatosCliente(cliente[0], cliente[1]));
		    	    boolean validarRegistro = !validarDatosCliente(cliente[0], cliente[1])||!validarDocumentosCliente(cliente[2], cliente[3]);
	            	log.info("validar registro: "+validarRegistro);
	            	if(validarRegistro)
	                {
	                	contadorRegistrosErroneos++;
	                	if(contadorRegistrosErroneos==1)
	                      archivo = crearArchivoLogValidacion();
	                	registro = obtenerRegistro(cliente);
		              	archivo.escribirTextoSL(registroLeido+","+registro);
		              	log.info("REGISTRO ERRONEO: "+registroLeido+","+registro);
	                }
              }
              else
              {
		            	contadorRegistrosErroneos++;
		            	if(contadorRegistrosErroneos==1)
		            		archivo = crearArchivoLogValidacion();
		              	registro = obtenerRegistro(cliente);
		                archivo.escribirTextoSL(registroLeido+","+registro);  
		              	log.info("REGISTRO ERRONEO: "+registroLeido+","+registro);

              }
			  registroLeido ++;
			}
		   }
		    catch(Exception e)
		    {
		    	throw new Exception(
						"No fue posible realizar la validacion del archivo\n"
								+ e.getMessage(), e.getCause()); 
		    }
		finally{
		    if(archivo != null)
		    	archivo.cerrarArchivo();
			return contadorRegistrosErroneos;
		}
	   }
	  

	  
	  public FileManager crearArchivoLogValidacion()
	  {
			String directorioEjecucionEquifax = JavaUtils.getPropiedad("directorio.validacion.archivo.equifax");
			crearDirectorioEquifax(directorioEjecucionEquifax);
	    	FileManager archivo =  new FileManager();
	  		crearDirectorioEquifax(directorioEjecucionEquifax);
	  		archivo.crearArchivo(directorioEjecucionEquifax.concat(JavaUtils.getPropiedad("archivo.log.validacion")));
			archivo.escribirTextoSL("ID,NOMBRE,APELLIDO,DUI,NIT");
	  		return archivo;
	  }
	  

	  
	  public String obtenerRegistro(String[] registro){
		  String linea ="";
		  for (int i = 0; i < registro.length; i++)
	      {
			linea = linea.concat(registro[i]).concat(",");  
	      }
		 linea = linea.substring(0, linea.length()>0?(linea.length()-1):linea.length());
		 return linea;
	  }

	  public boolean validarDatosCliente(String nombre, String apellido)
	  {
   	    //validamos que ninguno de estos dos valores este vacio
		if(nombre.isEmpty()||apellido.isEmpty()){
			 return false;
	    }
		return nombre.trim().matches("\\D+") && apellido.trim().matches("\\D+");
	  }
	  
	  public boolean validarDocumentosCliente(String documento1, String documento2)
	  {
			// validamos que exista por lo menos uno de los dos documentos
			if(documento1.isEmpty()&& documento2.isEmpty()){
				return false;
			} 
			return validarCampoNumerico(documento1, cantidadDigitosDui)&&validarCampoNumerico(documento2, cantidadDigitosNit);
	  }
	  
	  
	  //este metodo valida dos situaciones:
	  //1) si el numero esta vacio devuelve verdadero
	  //2) si el numero trae un valor este debe ser un numero en este caso devuelve verdadero
	  public boolean validarCampoNumerico(String documento, String longitud)
	  {
		 String regularExpresion = "\\d{"+longitud+"}+";
		 log.info(regularExpresion);
		 return documento.trim().length()>0?documento.trim().matches(regularExpresion):true;  
	  }
	  

	
	  public void crearDirectorioEquifax(String rutaFolder)
	  {
		  File directorio = new File (rutaFolder);
		    if(!directorio.exists()){
		    	directorio.mkdirs();
		    }
	  }
	  
	  
	  public VariableReporte consultarVariable(String respuestaXml)
	  {
		  LeerXml xml = new LeerXml(respuestaXml);
		  VariableReporte var = new VariableReporte(xml.extraerValor(xml.getRaiz(), "/codigoRetorno/"), xml.extraerValor(xml.getRaiz(), "/mensaje/"));
	      return var;
	  }
	  
	  public String consultarEquifaxCliente(String nombreDocumento,  String numeroDocumento) throws BureauServiceException, RemoteException
	  {
		    Usuario usuario = (new UsuarioControlador()).getUserProperties();
	        WSCollectorMate ws = new WSCollectorMate(usuario);
	        String tipoDocumento = JavaUtils.getPropiedad(nombreDocumento);
	        int i = contClientes - 1;
	        ++cantidadConsultasRealizadas;
	        String respuesta = xmlString.getXmls(i);
	        System.out.println(respuesta);
	        //String respuesta = ws.getCandidateInfo(tipoDocumento, numeroDocumento.trim());
	        respuesta = respuesta != null?respuesta:"";
	        log.info(respuesta);
	        return respuesta;

	  }
		  

	
	
}
